package com.hsck.order.kds.base.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;
import android.os.Parcelable;

import com.hsck.order.kds.base.common.Constant;

/**
 * 创建者 : ly
 * 时间 : 2018/1/17
 * 公司 : 工博
 * 功能 : 监听网络状态改变的广播
 */

public class NetworkConnectChangedReceiver extends BroadcastReceiver {

    private NetworkConnectListener networkConnectListener;

    public void setNetworkConnectListener(NetworkConnectListener networkConnectListener) {
        this.networkConnectListener = networkConnectListener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        try {
            // 这个监听wifi的打开与关闭，与wifi的连接无关
            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                LogUtil.d("wifiState" + wifiState);
                switch (wifiState) {
                    //WiFi正在关闭状态
                    case WifiManager.WIFI_STATE_DISABLING:
                        break;
                    //WiFi已经完全关闭状态
                    case WifiManager.WIFI_STATE_DISABLED:
                        Constant.INSTANCE.setEnablaWifi(false);
                        break;
                    //WiFi正在关闭状态
                    case WifiManager.WIFI_STATE_ENABLING:
                        break;
                    //WiFi已经完全开启状态
                    case WifiManager.WIFI_STATE_ENABLED:
                        Constant.INSTANCE.setEnablaWifi(true);
                        break;
                    //WiFi未知状态
                    case WifiManager.WIFI_STATE_UNKNOWN:
                        break;
                    default:
                        break;
                }
            }
            // 这个监听wifi的连接状态即是否连上了一个有效无线路由，当上边广播的状态是WifiManager
            // .WIFI_STATE_DISABLING，和WIFI_STATE_DISABLED的时候，根本不会接到这个广播。
            // 在上边广播接到广播是WifiManager.WIFI_STATE_ENABLED状态的同时也会接到这个广播，
            // 当然刚打开wifi肯定还没有连接到有效的无线
            if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                Parcelable parcelableExtra = intent
                        .getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (null != parcelableExtra) {
                    NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                    NetworkInfo.State state = networkInfo.getState();
                    boolean isConnected = state == NetworkInfo.State.CONNECTED;// 当然，这边可以更精确的确定状态
                    LogUtil.d("isConnected" + isConnected);
                    if (isConnected) {
                        Constant.INSTANCE.setWifi(true);
                    } else {
                        Constant.INSTANCE.setWifi(false);
                    }
                }
            }
            // 这个监听网络连接的设置，包括wifi和移动数据的打开和关闭。.
            // 最好用的还是这个监听。wifi如果打开，关闭，以及连接上可用的连接都会接到监听。见LogUtil
            // 这个广播的最大弊端是比上边两个广播的反应要慢，如果只是要监听wifi，我觉得还是用上边两个配合比较合适
            if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
                ConnectivityManager manager = (ConnectivityManager) context
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                LogUtil.i("CONNECTIVITY_ACTION");

                NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
                if (activeNetwork != null) { // connected to the internet
                    if (activeNetwork.isConnected()) {
                        if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                            // connected to wifi
                            Constant.INSTANCE.setWifi(true);
                            Constant.INSTANCE.setConnected(true);
                            LogUtil.d("当前WiFi连接可用 ");
                            networkConnectListener.networkRequest();
                        } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
                            // connected to the mobile provider's data plan
                            Constant.INSTANCE.setMobile(true);
                            Constant.INSTANCE.setConnected(true);
                            networkConnectListener.networkRequest();
                            LogUtil.d("当前移动网络连接可用 ");
                        }
                    } else {
                        LogUtil.d("当前没有网络连接，请确保你已经打开网络 ");
                    }


//                LogUtil.d("info.getTypeName()" + activeNetwork.getTypeName());
//                LogUtil.d("getSubtypeName()" + activeNetwork.getSubtypeName());
//                LogUtil.d("getState()" + activeNetwork.getState());
//                LogUtil.d("getDetailedState()"
//                        + activeNetwork.getDetailedState().name());
//                LogUtil.d("getDetailedState()" + activeNetwork.getExtraInfo());
//                LogUtil.d("getType()" + activeNetwork.getType());
                } else {   // not connected to the internet
                    LogUtil.d("当前没有网络连接，请确保你已经打开网络 ");
                    networkConnectListener.showNetworkDialog();
                    Constant.INSTANCE.setWifi(false);
                    Constant.INSTANCE.setMobile(false);
                    Constant.INSTANCE.setConnected(false);
                }
            }
        }catch (Exception exception){
            exception.printStackTrace();
        }
    }

}
